package com.huya.demo.minio.utils;

import com.huya.demo.minio.config.MinioConfig;
import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteObject;
import io.minio.messages.Item;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * MinIO 工具类
 *
 * @author huya
 * @date 2025-01-10
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class MinioUtils {

    private static final String IMAGE_EXTENSION = ".jpg";

    private final MinioClient minioClient;

    private final MinioConfig minioConfig;

    private final ExecutorService executorService;

    // region 桶相关

    /**
     * 获得所有 Bucket 列表
     */
    public List<Bucket> getAllBuckets() {
        try {
            return minioClient.listBuckets();
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 获得所有 Bucket 列表，异常：", e);
            return Collections.emptyList();
        }
    }

    /**
     * 判断 Bucket 是否存在，true：存在，false：不存在
     *
     * @param bucketName 桶名
     */
    public boolean bucketExists(String bucketName) {
        try {
            return minioClient.bucketExists(BucketExistsArgs
                    .builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 判断 Bucket 是否存在，异常：", e);
            return false;
        }
    }

    /**
     * 根据 bucketName 获取该桶信息
     *
     * @param bucketName 桶名
     */
    public Optional<Bucket> getBucketInfo(String bucketName) {
        List<Bucket> buckets = getAllBuckets();
        return buckets.stream().filter(bucket -> bucket.name().equals(bucketName)).findFirst();
    }

    /**
     * 获得 Bucket 的策略
     *
     * @param bucketName 桶名
     */
    public String getBucketPolicy(String bucketName) {
        try {
            return minioClient.getBucketPolicy(GetBucketPolicyArgs
                    .builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 获得 Bucket 的策略，异常：", e);
            return null;
        }
    }

    /**
     * 根据 bucketName 删除 bucket，true：删除成功； false：删除失败或文件已不存在
     *
     * @param bucketName 桶名
     */
    public void removeBucket(String bucketName) {
        try {
            minioClient.removeBucket(RemoveBucketArgs
                    .builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 根据 bucketName 删除 bucket，异常：", e);
        }
    }

    // endregion

    // region 文件夹或目录相关

    /**
     * 判断文件夹是否存在
     *
     * @param bucketName 桶名
     * @param objectName 文件对象名
     * @return 是否存在
     */
    public boolean isFolderExist(String bucketName, String objectName) {
        try {
            return minioClient.listObjects(ListObjectsArgs.builder()
                            .bucket(bucketName)
                            .prefix(objectName)
                            .recursive(false)
                            .build())
                    .iterator()
                    .hasNext(); // 直接判断是否有下一个元素即可
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 判断文件夹是否存在，异常：", e);
            return false;
        }
    }

    /**
     * 创建文件夹或目录
     *
     * @param bucketName 存储桶
     * @param dirPath    目录路径
     * @return 结果
     */
    public ObjectWriteResponse createDir(String bucketName, String dirPath) {
        try {
            return minioClient.putObject(PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(dirPath)
                    .stream(new ByteArrayInputStream(new byte[]{}), 0, -1)
                    .build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 创建文件夹或目录，异常：", e);
            return null;
        }
    }

    // endregion

    // region 文件相关

    /**
     * 判断文件是否存在
     *
     * @param bucketName 桶名
     * @param objectName 文件对象名
     * @return boolean 存在与否
     */
    public boolean isObjectExist(String bucketName, String objectName) {
        try {
            minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
            return true;
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 判断文件是否存在, 未知异常：", e);
            return false;
        }
    }

    /**
     * 根据文件前缀查询文件
     *
     * @param bucketName 存储桶
     * @param prefix     前缀
     * @param recursive  是否使用递归查询
     * @return MinioItem 列表
     */
    public List<Item> getAllObjectsByPrefix(String bucketName, String prefix, boolean recursive) {
        List<Item> list = new ArrayList<>();
        Iterable<Result<Item>> objectsIterator = minioClient.listObjects(ListObjectsArgs
                .builder()
                .bucket(bucketName)
                .prefix(prefix)
                .recursive(recursive)
                .build());
        if (objectsIterator != null) {
            for (Result<Item> result : objectsIterator) {
                try {
                    list.add(result.get());
                } catch (Exception e) {
                    log.error("[Minio 工具类]>>>> 根据文件前缀查询文件，异常：", e);
                }
            }
        }
        return list;
    }

    /**
     * 获取路径下文件列表
     *
     * @param bucketName 存储桶
     * @param prefix     文件名称
     * @param recursive  是否递归查找，false：模拟文件夹结构查找
     * @return Iterable<Result < Item>> 二进制流
     */
    public Iterable<Result<Item>> listObjects(String bucketName, String prefix, boolean recursive) {
        return minioClient.listObjects(ListObjectsArgs.builder()
                .bucket(bucketName)
                .prefix(prefix)
                .recursive(recursive)
                .build());
    }

    /**
     * 获取文件信息, 如果抛出异常则说明文件不存在
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @return 文件信息
     */
    public String getFileInfo(String bucketName, String objectName) {
        try {
            return minioClient.statObject(StatObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .build()).toString();
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 获取文件信息，异常：", e);
            return null;
        }
    }

    /**
     * 获取文件二进制流
     *
     * @param objectName 文件名
     * @return 二进制流
     */
    public InputStream getObject(String objectName) {
        try {
            return minioClient.getObject(GetObjectArgs.builder()
                    .bucket(minioConfig.getBucketName())
                    .object(objectName)
                    .build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 获取文件二进制流，异常：", e);
            return null;
        }
    }

    /**
     * 获取文件二进制流
     *
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @return 二进制流
     */
    public InputStream getObject(String bucketName, String objectName) {
        try {
            return minioClient.getObject(GetObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 获取文件二进制流，异常：", e);
            return null;
        }
    }

    /**
     * 获取文件外链
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @return url
     */
    public String getObjectUrl(String bucketName, String objectName) {
        try {
            return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .method(Method.GET).build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 获取文件外链，异常：", e);
            return null;
        }
    }

    /**
     * 获取文件外链
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @param expires    过期时间（1 秒到 7 天）
     * @return url
     */
    public String getPresignedObjectUrl(String bucketName, String objectName, Integer expires) {
        try {
            return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                    .expiry(expires)
                    .bucket(bucketName)
                    .object(objectName)
                    .method(Method.GET).build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 获取文件外链，异常：", e);
            return null;
        }
    }

    /**
     * 获取文件外链
     *
     * @param objectName 文件名称
     * @return url
     */
    public String getPresignedObjectUrl(String objectName) {
        return minioConfig.getEndpoint() + "/" + minioConfig.getBucketName() + "/" + objectName;
    }

    /**
     * 获取文件外链
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @return url
     */
    public String getPresignedObjectUrl(String bucketName, String objectName) {
        try {
            return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .method(Method.GET).build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 获取文件外链，异常：", e);
            return null;
        }
    }

    /**
     * 拷贝文件
     *
     * @param bucketName    存储桶
     * @param objectName    文件名
     * @param srcBucketName 目标存储桶
     * @param srcObjectName 目标文件名
     */
    public ObjectWriteResponse copyFile(String bucketName, String objectName, String srcBucketName, String srcObjectName) {
        try {
            return minioClient.copyObject(CopyObjectArgs.builder()
                    .source(CopySource.builder().bucket(bucketName).object(objectName).build())
                    .bucket(srcBucketName)
                    .object(srcObjectName)
                    .build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 拷贝文件，异常：", e);
            return null;
        }
    }

    /**
     * 删除文件
     *
     * @param objectName 文件名称
     */
    public boolean removeFile(String objectName) {
        try {
            minioClient.removeObject(RemoveObjectArgs.builder()
                    .bucket(minioConfig.getBucketName())
                    .object(objectName)
                    .build());
            return true;
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 删除文件，异常：", e);
        }
        return false;
    }

    /**
     * 删除文件
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     */
    public void removeFile(String bucketName, String objectName) {
        try {
            minioClient.removeObject(RemoveObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 删除文件，异常：", e);
        }
    }

    /**
     * 批量删除文件
     *
     * @param bucketName  存储桶
     * @param objectNames 需要删除的文件名称列表
     */
    public void removeFiles(String bucketName, List<String> objectNames) {
        List<DeleteObject> objectNameLinkedList = objectNames.stream()
                .map(DeleteObject::new)
                .collect(Collectors.toList());
        try {
            minioClient.removeObjects(RemoveObjectsArgs
                    .builder()
                    .bucket(bucketName)
                    .objects(objectNameLinkedList)
                    .build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 批量删除文件，异常：", e);
        }
    }

    // endregion

    // region 上传下载相关

    /**
     * 上传本地文件
     *
     * @param bucketName 存储桶
     * @param objectName 对象名称
     * @param fileName   本地文件路径
     * @return 结果
     */
    public ObjectWriteResponse uploadFile(String bucketName, String objectName, String fileName) {
        try {
            return minioClient.uploadObject(UploadObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .filename(fileName)
                    .build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 上传本地文件，异常：", e);
            return null;
        }
    }

    /**
     * 使用 MultipartFile 进行文件上传
     *
     * @param multipartFile 文件名
     * @return 结果
     */
    public String uploadFile(MultipartFile multipartFile) {
        String newFileName = generateNewFileName(multipartFile);
        try (InputStream inputStream = multipartFile.getInputStream()) {
            minioClient.putObject(createPutObjectArgs(minioConfig.getBucketName(), newFileName, multipartFile.getContentType(), inputStream));
            return minioConfig.getEndpoint() + "/" + minioConfig.getBucketName() + "/" + newFileName;
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 使用 MultipartFile 进行文件上传，异常：", e);
            return null;
        }
    }

    /**
     * 使用 MultipartFile 进行文件批量上传
     *
     * @param multipartFiles 文件列表
     * @return 结果列表
     */
    public List<String> uploadFiles(List<MultipartFile> multipartFiles) {
        List<Future<String>> futures = new ArrayList<>();
        for (MultipartFile multipartFile : multipartFiles) {
            futures.add(executorService.submit(() -> uploadFile(multipartFile)));
        }
        shutdownAndAwaitTermination(executorService);
        List<String> resultUrls = new ArrayList<>();
        for (Future<String> future : futures) {
            try {
                String url = future.get();
                if (url != null) {
                    resultUrls.add(url);
                }
            } catch (InterruptedException e) {
                log.error("[Minio 工具类]>>>> 使用 MultipartFile 进行文件批量上传，异常：", e);
                // 恢复中断状态
                Thread.currentThread().interrupt();
            } catch (Exception e) {
                log.error("[Minio 工具类]>>>> 使用 MultipartFile 进行文件批量上传，异常：", e);
            }
        }
        return resultUrls;
    }

    /**
     * 使用 MultipartFile 进行文件上传
     *
     * @param bucketName    存储桶
     * @param multipartFile 文件名
     * @param objectName    对象名
     * @param contentType   类型
     * @return 结果
     */
    public ObjectWriteResponse uploadFile(String bucketName, MultipartFile multipartFile, String objectName, String contentType) {
        try (InputStream inputStream = multipartFile.getInputStream()) {
            return minioClient.putObject(createPutObjectArgs(bucketName, objectName, contentType, inputStream));
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 使用 MultipartFile 进行文件上传，异常：", e);
            return null;
        }
    }

    /**
     * 通过流上传文件
     *
     * @param bucketName  存储桶
     * @param objectName  文件对象
     * @param inputStream 文件流
     * @return 结果
     */
    public ObjectWriteResponse uploadFile(String bucketName, String objectName, InputStream inputStream) {
        try {
            return minioClient.putObject(createPutObjectArgs(bucketName, objectName, null, inputStream));
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 通过流上传文件，异常：", e);
            return null;
        }
    }

    /**
     * 图片上传
     *
     * @param bucketName  存储桶
     * @param imageBase64 图片 base64
     * @param imageName   图片名
     * @return 结果
     */
    public ObjectWriteResponse uploadImage(String bucketName, String imageBase64, String imageName) {
        if (StringUtils.isNotEmpty(imageBase64)) {
            try (InputStream in = base64ToInputStream(imageBase64)) {
                String newName = generateNewImageName(imageName);
                String path = generatePath();
                return uploadFile(bucketName, path + newName, in);
            } catch (Exception e) {
                log.error("Error uploading image", e);
                return null;
            }
        }
        return null;
    }

    /**
     * 下载
     *
     * @param objectName 文件名称
     */
    public void downloadFile(String objectName, HttpServletResponse httpServletResponse) {
        InputStream inputStream = getObject(objectName);
        httpServletResponse.setHeader("Content-Disposition", "attachment;filename=" + objectName);
        httpServletResponse.setContentType("application/force-download");
        httpServletResponse.setCharacterEncoding("UTF-8");
        try {
            IOUtils.copy(inputStream, httpServletResponse.getOutputStream());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 下载，异常：", e);
        }
    }

    /**
     * 断点下载
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @param offset     起始字节的位置
     * @param length     要读取的长度
     * @return 二进制流
     */
    public InputStream getObject(String bucketName, String objectName, long offset, long length) {
        try {
            return minioClient.getObject(GetObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .offset(offset)
                    .length(length)
                    .build());
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 断点下载，异常：", e);
            return null;
        }
    }

    // endregion

    /**
     * base64 转输入流
     *
     * @param base64 base64
     * @return 输入流
     */
    public static InputStream base64ToInputStream(String base64) {
        byte[] bytes = Base64.getDecoder().decode(base64.trim());
        return new ByteArrayInputStream(bytes);
    }

    /**
     * 创建上传文件参数
     *
     * @param bucketName  存储桶
     * @param objectName  文件名
     * @param contentType 文件类型
     * @param inputStream 文件流
     * @return 上传文件参数
     */
    private PutObjectArgs createPutObjectArgs(String bucketName, String objectName, String contentType, InputStream inputStream) {
        try {
            return PutObjectArgs.builder()
                    .bucket(bucketName)
                    .object(objectName)
                    .contentType(contentType)
                    .stream(inputStream, inputStream.available(), -1)
                    .build();
        } catch (Exception e) {
            log.error("[Minio 工具类]>>>> 创建上传文件参数，异常：", e);
            return null;
        }
    }

    /**
     * 关闭并等待线程池终止的方法。
     * 首先尝试正常关闭线程池，如果超时则强制关闭。
     * 如果再次超时，记录错误日志。
     *
     * @param pool 要关闭的线程池
     */
    private void shutdownAndAwaitTermination(ExecutorService pool) {
        // 禁止提交新任务
        pool.shutdown();
        try {
            // 等待一段时间让现有任务完成
            if (!pool.awaitTermination(60, TimeUnit.MINUTES)) {
                // 取消当前正在执行的任务
                pool.shutdownNow();
                // 等待一段时间让任务响应取消请求
                if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
                    log.error("[Minio 工具类]>>>> 线程池未能正常终止");
                }
            }
        } catch (InterruptedException ie) {
            // 如果当前线程也被中断，则重新取消
            pool.shutdownNow();
            // 保留中断状态
            Thread.currentThread().interrupt();
        }
    }

    /**
     * 生成路径
     *
     * @return 路径
     */
    private String generatePath() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd/");
        return sdf.format(new Date());
    }

    /**
     * 生成新文件名
     *
     * @param multipartFile multipartFile
     * @return 新文件名
     */
    private String generateNewFileName(MultipartFile multipartFile) {
        if (multipartFile == null || StringUtils.isBlank(multipartFile.getOriginalFilename())) {
            throw new IllegalArgumentException("Invalid file or filename");
        }
        String fileName = multipartFile.getOriginalFilename();
        String extension = StringUtils.substringAfterLast(fileName, ".");
        if (StringUtils.isBlank(extension)) {
            throw new IllegalArgumentException("File does not have a valid extension");
        }
        return System.currentTimeMillis() + "." + extension;
    }

    /**
     * 生成新图片名
     *
     * @param imageName 图片名
     * @return 新图片名
     */
    private String generateNewImageName(String imageName) {
        long currentTimeMillis = System.currentTimeMillis();
        return currentTimeMillis + "_" + imageName + IMAGE_EXTENSION;
    }

}
